package com.xuetang9.fujian.threaddemo.threadpooldemo;

import java.util.LinkedList;
import java.util.Queue;

/**
 * @author: fujian
 * @description: 自定义线程池，使用到生产者与消费者模型
 * @date: 2021/5/9 9:03
 * @version: V1.0
 * @package: com.xuetang9.fujian.threaddemo.threadpooldemo
 **/
@SuppressWarnings("all")
public class ThreadPool extends ThreadGroup{
    private int maxThread;
    private boolean isAlive;
    private Queue<Runnable> taskQueue;
    /*
     * @Description: 自定义线程池
     * @param: maxThread 最大的活动线程数
     * @author: fujian
     * @date 2021/5/10 14:52
    */
    public ThreadPool(String maxThread) {
        super("当前线程池中最大的线程数：" + maxThread);
        this.maxThread = Integer.parseInt(maxThread);
        this.isAlive = true;
        taskQueue = new LinkedList<Runnable>();
        // 需要有固定的活动线程去执行队列中的任务
        for (int i = 0; i < this.maxThread; i++) {
            // 调用start方法，不要直接调用run方法
            new PooledThread().start();
        }
    }

    /*
     * @Description: 从任务队列中取出一个待执行的任务
     * @param:
     * @return java.lang.Runnable
     * @author: fujian
     * @date 2021/5/9 9:12
    */
    public synchronized Runnable getTask() throws InterruptedException {
        while (taskQueue.size() == 0){
            wait();
        }
        return taskQueue.poll();
    }
    /*
     * @Description: 将要执行的任务对象添加到任务队列中，在下一个可用的线程中去执行
     * @param: task
     * @return void
     * @author: fujian
     * @date 2021/5/9 9:15
    */
    public synchronized void runTask(Runnable task){
        if (!isAlive) throw new IllegalStateException("当前线程池已经关闭，无法执行新任务");
        if (null != task){
            taskQueue.offer(task);
            notifyAll();
        }
    }

    protected void join(){
        synchronized (this){
            isAlive = false;
            notifyAll();
        }
        Thread[] threads = new Thread[this.activeCount()];
        int count = this.enumerate(threads);
        for (int i = 0; i < count; i++) {
            try {
                threads[i].join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("线程池已经全部关闭");
    }

    /**
     * @author fujian
     * @ClassName: ThreadPool
     * @desctiption 池化线程，是线程池中的一个对象
     * @date 2021/5/9 9:09
     * @version V1.0
    **/
    private class PooledThread extends Thread{

        public PooledThread() {
        }

        @Override
        public void run() {
            while (isAlive || taskQueue.size() != 0){
                // 取出要执行的任务，在这里执行任务
                Runnable task = null;
                try {
                    task = getTask();
                    if (null == task) break;
                    task.run();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}